/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.foxinline.manager.pesquisar;

import br.com.foxinline.enums.ProjetoStatus;
import br.com.foxinline.enums.TipoDocumento;
import br.com.foxinline.manager.criar.ManagerCriarProtocolo;
import br.com.foxinline.modelo.*;
import br.com.foxinline.servico.*;
import br.com.foxinline.util.Msg;
import br.com.foxinline.utilitarios.ArquivoUtilitario;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.servlet.http.HttpServletRequest;
import org.primefaces.context.RequestContext;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.DualListModel;
import org.primefaces.model.chart.CartesianChartModel;
import org.primefaces.model.chart.LineChartSeries;

/**
 *
 * @author laverson
 */
@ViewScoped
@ManagedBean
public class ManagerPesquisarProjeto implements Serializable {

    @EJB
    ProjetoServico projetoServico;
    @EJB
    UsuarioServico usuarioServico;
    @EJB
    SituacaoServico situacaoServico;
    @EJB
    ComentarioServico comentarioServico;
    @EJB
    LancamentoServico lancamentoServico;
    @EJB
    SecretariaServico secretariaServico;
    @EJB
    PessoaServico pessoaServico;
    @EJB
    MensagemServico mensagemServico;
    private Projeto projetoPesquisar;
    private Projeto projetoEditar;
    private Projeto projetoVisualizar;
    private Projeto projetoDeletar;
    private List<Projeto> projetos;
    private Situacao situacaoCriar;
    private List<Situacao> situacoesPesquisar;
    private List<Situacao> situacoesEditar;
    private List<Situacao> situacoesVisualizar;
    private Lancamento lancamentoCriar;
    private List<Lancamento> lancamentosPesqusiar;
    private List<Lancamento> lancamentosEditar;
    private List<Lancamento> lancamentosVisualizar;
    private Secretaria secretariaPesquisar;
    private Secretaria secretariaEditar;
    private Secretaria secretariaVisualizar;
    private Secretaria secretariaSituacao;
    private Usuario usuarioNotificar;
    private List<Comentario> comentarios;
    private List<Anexo> anexoComentario;
    private List<Usuario> usuarios;
    private Comentario comentario;
    private Date dataInicial;
    private Date dataFinal;
    private String eProjeto;
    private String vProjeto;
    private ArquivoUtilitario arquivoUtilitario;
    private BigDecimal totalLancamentos;
    private Secretaria secretaria;
    private Usuario responsavel;
    private Usuario responsavelPesquisar;
    private DualListModel<Usuario> acompanhantes;
    private Endereco endereco;
    private Endereco enderecoEmpresa;
    private Pessoa empresa;
    private Pessoa empresaPesquisar;
    private List<Pessoa> empresas;
    private List<Secretaria> secretarias;
    private List<Usuario> target;
    private CartesianChartModel grf;

    @PostConstruct
    public void init() {
        projetoPesquisar = new Projeto();
        projetoPesquisar.setEmpresa(new Pessoa());
        situacoesPesquisar = new ArrayList<Situacao>();
        lancamentosPesqusiar = new ArrayList<Lancamento>();
        secretariaPesquisar = new Secretaria();
        secretariaSituacao = new Secretaria();
        projetos = projetoServico.findLimit(null);
        anexoComentario = new ArrayList<Anexo>();
        usuarioNotificar = new Usuario();
        responsavelPesquisar = new Usuario();
        empresaPesquisar = new Pessoa();

        Map<String, String> params = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap();
        eProjeto = params.get("eProjeto");
        vProjeto = params.get("vProjeto");
        paramPost();
        getRequestURL();
    }

    public void getRequestURL() {
        Object request = FacesContext.getCurrentInstance().getExternalContext().getRequest();
        if (request instanceof HttpServletRequest) {
            String string = ((HttpServletRequest) request).getRequestURL().toString();

            System.err.println(string);
        }
    }

    private void initLinearModel() {
        CartesianChartModel model = new CartesianChartModel();

        LineChartSeries series1 = new LineChartSeries("Desempenho");


        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

        Collections.reverse(situacoesVisualizar);
        for (int i = 0; i < situacoesVisualizar.size(); i++) {
            series1.set(sdf.format(situacoesVisualizar.get(i).getDataCriacao()), situacoesVisualizar.get(i).getEstagio());
        }

        Collections.reverse(situacoesVisualizar);

        model.addSeries(series1);

        grf = model;
    }

    public void paramPost() {
        try {
            if (eProjeto != null) {
                projetoEditar = projetoServico.pesquisar(Long.parseLong(eProjeto));

                if (projetoEditar.getResponsavel() == null || projetoEditar.getResponsavel().getId() == null) {
                    projetoEditar.setResponsavel(new Usuario());
                }

                responsavel = projetoEditar.getResponsavel();
                situacoesEditar = projetoEditar.getSituacoes() != null ? projetoEditar.getSituacoes() : new ArrayList<Situacao>();
                lancamentosEditar = projetoEditar.getLancamentos() != null ? projetoEditar.getLancamentos() : new ArrayList<Lancamento>();
                secretariaEditar = projetoEditar.getSecretaria() != null ? projetoEditar.getSecretaria() : new Secretaria();
                target = projetoEditar.getAcompanhantes();
                acompanhantes = new DualListModel<Usuario>(usuarioServico.notContainsIn(target), target);
                endereco = projetoEditar.getEndereco();
                empresa = projetoEditar.getEmpresa() != null ? projetoEditar.getEmpresa() : new Pessoa();
                enderecoEmpresa = empresa.getEndereco() != null ? empresa.getEndereco() : new Endereco();
                secretaria = projetoEditar.getSecretaria() != null ? projetoEditar.getSecretaria() : new Secretaria();
                arquivoUtilitario = new ArquivoUtilitario();
                return;
            }
            if (vProjeto != null) {
                situacaoCriar = new Situacao();
                lancamentoCriar = new Lancamento();
                comentario = new Comentario();
                arquivoUtilitario = new ArquivoUtilitario();
                projetoVisualizar = projetoServico.pesquisar(Long.parseLong(vProjeto));
                loadSituacao();
                loadLancamento();
                totalLancamentos = lancamentoServico.getValoresLancamento(projetoVisualizar);
                secretariaVisualizar = projetoVisualizar.getSecretaria() != null ? projetoVisualizar.getSecretaria() : new Secretaria();
                //comentarios = situacaoServico.situacaoAtual(null).getComentarios();
                initLinearModel();
                return;
            }
            projetos = projetoServico.findLimit(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void loadSituacao() {
        situacoesVisualizar = situacaoServico.getSituacao(projetoVisualizar);
    }

    public void loadLancamento() {
        lancamentosVisualizar = lancamentoServico.getLancamento(projetoVisualizar);
    }

    public void atualizar() {
        try {
            empresa.setEndereco(enderecoEmpresa);

            arquivoUtilitario.gravarAnexos(projetoEditar.getAnexos());

            projetoEditar.setEmpresa(empresa);
            projetoEditar.setEndereco(endereco);
            projetoEditar.setSecretaria(secretaria);
            projetoEditar.setSituacoes(situacoesEditar);
            projetoEditar.setLancamentos(lancamentosEditar);
            projetoServico.atualizar(projetoEditar);
            Msg.messagemInfoRedirect(Msg.SuccessFull, "visualizarprojeto.xhtml?vProjeto=" + projetoEditar.getId());
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemError(Msg.Failure);
        }
    }

    public void pesquisar() {
        projetos = projetoServico.find(projetoPesquisar, projetoPesquisar.getVigenciaInicial(), projetoPesquisar.getVigenciaFinal());
    }

    public void deletar() {
        try {
            projetoServico.remover(projetoDeletar);
            projetos.remove(projetoDeletar);
            Msg.messagemInfo(Msg.SuccessFull);
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemError(Msg.Failure);
        }
    }

    public void salvarSituacao() {
        try {
            if (situacaoCriar != null && situacaoCriar.getEstagio() != null) {
                projetoVisualizar.setEstagio(situacaoCriar.getEstagio());
            }
            if (secretariaSituacao != null && secretariaSituacao.getId() != null) {
                situacaoCriar.setSecretariaNotificada(secretariaSituacao);
            }
            if (usuarioNotificar != null && usuarioNotificar.getId() != null) {
                situacaoCriar.setUsuarionotificado(usuarioNotificar);
            }

            situacaoCriar.setUsuario(usuarioServico.getCurrentUser());
            situacaoCriar.setDataCriacao(new Date());
            projetoVisualizar.getSituacoes().add(situacaoCriar);
            projetoServico.atualizar(projetoVisualizar);
            Msg.messagemInfo(Msg.SuccessFull);

            loadSituacao();
            initLinearModel();

            Mensagem mensagem = new Mensagem();
            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
            //MENSAGEM DE NOVA SITUAÇÃO
            if (projetoVisualizar != null) {
                Projeto projeto = projetoVisualizar;
                mensagem = new Mensagem();
                mensagem.setProjeto(projeto);
                mensagem.setUserFrom(situacaoCriar.getUsuario());
                mensagem.setDateMessage(new Date());
                mensagem.setSubject("Nova Situação no Projeto: " + projetoVisualizar.getNome());
                mensagem.setText("Foi adicionado uma nova situação no projeto " + projetoVisualizar.getNome()
                        + ", em  " + sdf.format(projetoVisualizar.getDataEntrada()) + " por " + situacaoCriar.getUsuario().getNome()
                        + ", com o titulo " + situacaoCriar.getTitulo() + ", estado " + situacaoCriar.getProjetoStatus().getNome()
                        + " e estágio " + situacaoCriar.getEstagio());

                //QUEM ACOMPANHA
                for (Usuario usuario : projeto.getAcompanhantes()) {
                    if ((situacaoCriar.getUsuarionotificado() != null && usuario != situacaoCriar.getUsuarionotificado())
                            && (projeto.getResponsavel() != null && usuario != projeto.getResponsavel())
                            && (projeto.getUsuario() != null && usuario != projeto.getUsuario())) {
                        mensagem.setUserTo(usuario);
                        mensagemServico.salvar(mensagem);
                        mensagem.setId(null);
                    }
                }

                //O NOTIFICADO
                if (situacaoCriar.getUsuarionotificado() != null) {
                    mensagem.setId(null);
                    mensagem.setSubject("NOTIFICADO: " + mensagem.getSubject());
                    mensagem.setText("Você foi NOTIFICADO diante uma situação do projeto " + projeto.getNome()
                            + ", o projeto encontra-se " + situacaoCriar.getProjetoStatus().getNome() + ". Acesse o projeto para mais detalhes.");
                    mensagem.setUserTo(situacaoCriar.getUsuarionotificado());
                    mensagemServico.salvar(mensagem);
                }

                //O RESPONSÁVEL
                if (projeto.getResponsavel() != null) {
                    mensagem.setId(null);
                    mensagem.setUserTo(projeto.getResponsavel());
                    mensagemServico.salvar(mensagem);
                }

                // QUEM CRIOU O PROJETO
                if (projeto.getUsuario() != null
                        && (projeto.getResponsavel() != null && projeto.getUsuario() != projeto.getResponsavel())) {
                    mensagem.setId(null);
                    mensagem.setUserTo(projeto.getUsuario());
                    mensagemServico.salvar(mensagem);
                }

            }

            mensagem = new Mensagem();
            situacaoCriar = new Situacao();
            secretariaSituacao = new Secretaria();
            usuarioNotificar = new Usuario();
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemInfo(Msg.Failure);
        }
    }

    public void salvarLancamento() {
        try {
            if (projetoVisualizar.getLancamentos() == null) {
                projetoVisualizar.setLancamentos(new ArrayList<Lancamento>());
            }
            lancamentoCriar.setUsuario(usuarioServico.getCurrentUser());
            Calendar gc = GregorianCalendar.getInstance();

            lancamentoCriar.setDataCriacao(gc.getTime());

            if (lancamentoCriar.getValor() == null) {
                lancamentoCriar.setValor(BigDecimal.ZERO);
            }
            if (projetoVisualizar.getLancamentos() == null) {
                projetoVisualizar.setLancamentos(new ArrayList<Lancamento>());
            }
            projetoVisualizar.getLancamentos().add(lancamentoCriar);
            projetoServico.atualizar(projetoVisualizar);
            Msg.messagemInfo(Msg.SuccessFull);

            loadLancamento();
            lancamentoCriar = new Lancamento();
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemInfo(Msg.Failure);
        }
    }

    public List<SelectItem> selectProjetoStatus() {
        List<SelectItem> items = new ArrayList<SelectItem>();
        for (ProjetoStatus ps : ProjetoStatus.values()) {
            items.add(new SelectItem(ps, ps.getNome()));
        }
        return items;
    }
    private static int tamanhoMaximoNome = 10;

    public String nomeAnexo(Anexo a) {
        if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
            return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
        }
        return a.getNomeExibicao().replace(".png", "").replace(" ", "_");
    }

    public String nomeAnexoPdf(Anexo a) {
        if (a.getNomeExibicao().length() >= tamanhoMaximoNome) {
            return a.getNomeExibicao().substring(0, tamanhoMaximoNome).concat("...");
        }
        return a.getNomeExibicao().replace(".pdf", "").replace(" ", "_");
    }

    public List<Secretaria> todasSecretarias() {
        return secretariaServico.pesquisarTodos();
    }

    public Usuario getUsuarioNotificar() {
        return usuarioNotificar;
    }

    public void setUsuarioNotificar(Usuario usuarioNotificar) {
        this.usuarioNotificar = usuarioNotificar;
    }

    public Secretaria getSecretariaSituacao() {
        return secretariaSituacao;
    }

    public void setSecretariaSituacao(Secretaria secretariaSituacao) {
        this.secretariaSituacao = secretariaSituacao;
    }

    public Date getDataFinal() {
        return dataFinal;
    }

    public void setDataFinal(Date dataFinal) {
        this.dataFinal = dataFinal;
    }

    public Date getDataInicial() {
        return dataInicial;
    }

    public void setDataInicial(Date dataInicial) {
        this.dataInicial = dataInicial;
    }

    public List<Lancamento> getLancamentosPesqusiar() {
        return lancamentosPesqusiar;
    }

    public void setLancamentosPesqusiar(List<Lancamento> lancamentosPesqusiar) {
        this.lancamentosPesqusiar = lancamentosPesqusiar;
    }

    public List<Lancamento> getLancamentosVisualizar() {
        return lancamentosVisualizar;
    }

    public void setLancamentosVisualizar(List<Lancamento> lancamentosVisualizar) {
        this.lancamentosVisualizar = lancamentosVisualizar;
    }

    public Projeto getProjetoEditar() {
        return projetoEditar;
    }

    public void setProjetoEditar(Projeto projetoEditar) {
        this.projetoEditar = projetoEditar;
    }

    public Projeto getProjetoPesquisar() {
        return projetoPesquisar;
    }

    public void setProjetoPesquisar(Projeto projetoPesquisar) {
        this.projetoPesquisar = projetoPesquisar;
    }

    public Projeto getProjetoVisualizar() {
        return projetoVisualizar;
    }

    public void setProjetoVisualizar(Projeto projetoVisualizar) {
        this.projetoVisualizar = projetoVisualizar;
    }

    public Secretaria getSecretariaEditar() {
        return secretariaEditar;
    }

    public void setSecretariaEditar(Secretaria secretariaEditar) {
        this.secretariaEditar = secretariaEditar;
    }

    public Secretaria getSecretariaPesquisar() {
        return secretariaPesquisar;
    }

    public void setSecretariaPesquisar(Secretaria secretariaPesquisar) {
        this.secretariaPesquisar = secretariaPesquisar;
    }

    public Secretaria getSecretariaVisualizar() {
        return secretariaVisualizar;
    }

    public void setSecretariaVisualizar(Secretaria secretariaVisualizar) {
        this.secretariaVisualizar = secretariaVisualizar;
    }

    public List<Situacao> getSituacoesEditar() {
        return situacoesEditar;
    }

    public void setSituacoesEditar(List<Situacao> situacoesEditar) {
        this.situacoesEditar = situacoesEditar;
    }

    public List<Situacao> getSituacoesPesquisar() {
        return situacoesPesquisar;
    }

    public void setSituacoesPesquisar(List<Situacao> situacoesPesquisar) {
        this.situacoesPesquisar = situacoesPesquisar;
    }

    public List<Situacao> getSituacoesVisualizar() {
        return situacoesVisualizar;
    }

    public void setSituacoesVisualizar(List<Situacao> situacoesVisualizar) {
        this.situacoesVisualizar = situacoesVisualizar;
    }

    public List<Lancamento> getLancamentosEditar() {
        return lancamentosEditar;
    }

    public void setLancamentosEditar(List<Lancamento> lancamentosEditar) {
        this.lancamentosEditar = lancamentosEditar;
    }

    public Projeto getProjetoDeletar() {
        return projetoDeletar;
    }

    public void setProjetoDeletar(Projeto projetoDeletar) {
        this.projetoDeletar = projetoDeletar;
    }

    public List<Projeto> getProjetos() {
        return projetos;
    }

    public void setProjetos(List<Projeto> projetos) {
        this.projetos = projetos;
    }

    public Situacao getSituacaoCriar() {
        return situacaoCriar;
    }

    public void setSituacaoCriar(Situacao situacaoCriar) {
        this.situacaoCriar = situacaoCriar;
    }

    public void addComentario(int id) {
        RequestContext context = RequestContext.getCurrentInstance();
        String jsParam = getJsParam("projetoForm:repeatsituacao:" + id + ":comentarioInput");


        comentario.setDescricao(jsParam);
        Situacao situacao = situacoesVisualizar.get(id);
        comentarios = situacao.getComentarios() == null ? new ArrayList<Comentario>() : situacao.getComentarios();

        arquivoUtilitario.gravarAnexos(anexoComentario);
        comentario.setAnexo(anexoComentario);
        comentario.setDataCriacao(new Date());
        comentario.setUsuario(usuarioServico.getCurrentUser());
        comentarioServico.salvar(comentario);
        comentarios.add(comentario);
        situacao.setComentarios(comentarios);
        situacaoServico.atualizar(situacao);


        Mensagem mensagem = new Mensagem();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        //MENSAGEM DE NOVA SITUAÇÃO
        if (projetoVisualizar != null) {
            Projeto projeto = projetoVisualizar;


            mensagem = new Mensagem();
            mensagem.setProjeto(projeto);
            mensagem.setUserFrom(comentario.getUsuario());
            mensagem.setDateMessage(new Date());
            mensagem.setSubject(comentario.getUsuario().getNome() + " comentou o projeto " + projetoVisualizar.getNome());
            mensagem.setText(comentario.getUsuario().getNome() + " comentou o projeto " + projetoVisualizar.getNome()
                    + " em " + sdf.format(comentario.getDataCriacao())
                    + ": " + comentario.getDescricao() + ""
                    + (comentario.getAnexo() != null && !comentario.getAnexo().isEmpty() ? "e anexou " + (comentario.getAnexo().size() > 1 ? "arquivos" : " um arquivo") : ""));

            //QUEM ACOMPANHA
            for (Usuario usuario : projeto.getAcompanhantes()) {

                if ((situacaoCriar.getUsuarionotificado() != null && usuario != situacaoCriar.getUsuarionotificado())
                        && (projeto.getResponsavel() != null && usuario != projeto.getResponsavel())
                        && (projeto.getUsuario() != null && usuario != projeto.getUsuario())) {
                    mensagem.setUserTo(usuario);
                    mensagemServico.salvar(mensagem);
                    mensagem.setId(null);
                }
            }

            //RESPONSÁVEL PROJETO
            if (projeto.getResponsavel() != null) {
                mensagem.setId(null);
                mensagem.setUserTo(projeto.getResponsavel());
                mensagemServico.salvar(mensagem);
            }

            //QUEM CRIOU O PROJETO
            if (projeto.getUsuario() != null
                    && (projeto.getResponsavel() != null && projeto.getUsuario() != projeto.getResponsavel())) {
                mensagem.setId(null);
                mensagem.setUserTo(projeto.getUsuario());
                mensagemServico.salvar(mensagem);
            }

        }
        mensagem = new Mensagem();

        loadSituacao();
        comentario = new Comentario();
        anexoComentario = new ArrayList<Anexo>();
    }

    public static String getJsParam(String paramName) {
        javax.faces.context.FacesContext jsf = javax.faces.context.FacesContext.getCurrentInstance();
        Map<String, String> requestParameterMap = jsf.getExternalContext().getRequestParameterMap();
        System.err.println(requestParameterMap);
        String paramValue = requestParameterMap.get(paramName);
        if (paramValue != null) {
            paramValue = paramValue.trim();
            if (paramValue.length() == 0) {
                paramValue = null;
            }
        }
        return paramValue;
    }

    public Comentario getComentario() {
        return comentario;
    }

    public void setComentario(Comentario comentario) {
        this.comentario = comentario;
    }

    public void handleAnnex(FileUploadEvent event) throws IOException {
        try {
            if (situacaoCriar.getAnexos() == null) {
                situacaoCriar.setAnexos(new ArrayList<Anexo>());
            }
            situacaoCriar.getAnexos().add(arquivoUtilitario.adicionarArquivo(event));

        } catch (FileNotFoundException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void handleAnnexLancamento(FileUploadEvent event) throws IOException {
        try {
            if (lancamentoCriar.getAnexos() == null) {
                lancamentoCriar.setAnexos(new ArrayList<Anexo>());
            }
            lancamentoCriar.getAnexos().add(arquivoUtilitario.adicionarArquivo(event));

        } catch (FileNotFoundException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void handleAnnexComentario(FileUploadEvent event) throws IOException {
        try {
            anexoComentario.add(arquivoUtilitario.adicionarArquivo(event));
            Msg.messagemInfo("Arquivo anexado!");

        } catch (FileNotFoundException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void handleAnnexProjeto(FileUploadEvent event) throws IOException {
        try {
            if (projetoEditar.getAnexos() == null) {
                projetoEditar.setAnexos(new ArrayList<Anexo>());
            }
            System.err.println(event);
            Anexo anex = arquivoUtilitario.adicionarArquivo(event);
            System.err.println(anex);
            projetoEditar.getAnexos().add(anex);
//            Msg.messagemInfo("Arquivo anexado!");

        } catch (FileNotFoundException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(ManagerCriarProtocolo.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void removerAnexo(Anexo anexo) {
        try {
            arquivoUtilitario.excluirArquivo(new File(anexo.getUrl() + anexo.getNome()));
            situacaoCriar.getAnexos().remove(anexo);
        } catch (Exception e) {
            Msg.messagemError(Msg.Failure);
        }
    }

    public void removerAnexoLancamento(Anexo anexo) {
        try {
            arquivoUtilitario.excluirArquivo(new File(anexo.getUrl() + anexo.getNome()));
            lancamentoCriar.getAnexos().remove(anexo);
        } catch (Exception e) {
            Msg.messagemError(Msg.Failure);
        }
    }

    public void removerAnexoComentario(Anexo anexo) {
        try {
            arquivoUtilitario.excluirArquivo(new File(anexo.getUrl() + anexo.getNome()));
            anexoComentario.remove(anexo);
        } catch (Exception e) {
            Msg.messagemError(Msg.Failure);
        }
    }

    public void removerAnexoProjeto(Anexo anexo) {
        try {
            arquivoUtilitario.excluirArquivo(new File(anexo.getUrl() + anexo.getNome()));
            projetoEditar.getAnexos().remove(anexo);
        } catch (Exception e) {
            e.printStackTrace();
            Msg.messagemError(Msg.Failure);
        }
    }

    public String situacaoAtual(Long projeto) {
        Situacao p = situacaoServico.situacaoAtual(projeto);
        if (p != null) {
            return p.getProjetoStatus().getNome();
        } else {
            return "";
        }
    }

    public int estadoProjeto(int id) {
        if (projetos.get(id).getVigenciaFinal() != null) {

            Calendar gc = GregorianCalendar.getInstance();

            if (projetos.get(id).getVigenciaFinal() != null) {
                return dataDiff(gc.getTime(), projetos.get(id).getVigenciaFinal());
            }

        }
        return 0;
    }

    public void pesquisarResponsavel() {
        usuarios = usuarioServico.pesquisarUsuario(usuarioNotificar);
    }

    public void setarResponsavel(Usuario usuario) {
//        this.responsavel = usuario;
        usuarioNotificar = usuario;
    }

    public void removerResponsavel() {
//        this.responsavel = new Usuario();
        usuarioNotificar = new Usuario();
    }

    /**
     * Diferença de datas, retorna a quantidade de dias
     *
     * @param dataLow
     * @param dataHigh
     * @return
     */
    public static int dataDiff(java.util.Date dataLow, java.util.Date dataHigh) {

        GregorianCalendar startTime = new GregorianCalendar();
        GregorianCalendar endTime = new GregorianCalendar();

        GregorianCalendar curTime = new GregorianCalendar();
        GregorianCalendar baseTime = new GregorianCalendar();

        startTime.setTime(dataLow);
        endTime.setTime(dataHigh);

        int dif_multiplier = 1;

        // Verifica a ordem de inicio das datas  
        if (dataLow.compareTo(dataHigh) < 0) {
            baseTime.setTime(dataHigh);
            curTime.setTime(dataLow);
            dif_multiplier = 1;
        } else {
            baseTime.setTime(dataLow);
            curTime.setTime(dataHigh);
            dif_multiplier = -1;
        }

        int result_years = 0;
        int result_months = 0;
        int result_days = 0;

        // Para cada mes e ano, vai de mes em mes pegar o ultimo dia para import acumulando  
        // no total de dias. Ja leva em consideracao ano bissesto  
        while (curTime.get(GregorianCalendar.YEAR) < baseTime.get(GregorianCalendar.YEAR)
                || curTime.get(GregorianCalendar.MONTH) < baseTime.get(GregorianCalendar.MONTH)) {

            int max_day = curTime.getActualMaximum(GregorianCalendar.DAY_OF_MONTH);
            result_months += max_day;
            curTime.add(GregorianCalendar.MONTH, 1);

        }

        // Marca que é um saldo negativo ou positivo  
        result_months = result_months * dif_multiplier;


        // Retorna a diferenca de dias do total dos meses  
        result_days += (endTime.get(GregorianCalendar.DAY_OF_MONTH) - startTime.get(GregorianCalendar.DAY_OF_MONTH));

        return result_years + result_months + result_days;
    }

    public void removerEmpresa() {
        this.empresa = new Pessoa();
    }

    public void setarEmpresa(Pessoa pessoa) {
        this.empresa = pessoa;
        enderecoEmpresa = this.empresa.getEndereco();
    }

    public void pesquisarEmpresa() {
        empresaPesquisar.setTipoDocumento(TipoDocumento.CNPJ);
        empresas = pessoaServico.find(empresaPesquisar, null);
    }

    public void pesquisarSecretaria() {
        secretarias = secretariaServico.pesquisarSecretaria(secretariaPesquisar);
    }

    public void removerSecretaria() {
        secretaria = new Secretaria();
    }

    public void setarSecretaria(Secretaria secretaria) {
        this.secretaria = secretaria;
    }

    /**
     * Verifica se o usuário logado possui permissão para editar o projeto
     *
     * @return <b>true</b>, caso possa editar, <b>false</b>, caso contrário
     */
    public boolean habilitarEdicao() {
        return usuarioServico.isUsuarioProjeto(usuarioServico.getCurrentUser());
    }

    public Lancamento getLancamentoCriar() {
        return lancamentoCriar;
    }

    public void setLancamentoCriar(Lancamento lancamentoCriar) {
        this.lancamentoCriar = lancamentoCriar;
    }

    public BigDecimal getTotalLancamentos() {
        return totalLancamentos;
    }

    public void setTotalLancamentos(BigDecimal totalLancamentos) {
        this.totalLancamentos = totalLancamentos;
    }

    public List<Usuario> getUsuarios() {
        return usuarios;
    }

    public void setUsuarios(List<Usuario> usuarios) {
        this.usuarios = usuarios;
    }

    public void relatorio() {
        projetoServico.report(projetoVisualizar);
    }

    public void relatorioAll() {
        projetoServico.reportAll(projetos);
    }

    public Secretaria getSecretaria() {
        return secretaria;
    }

    public void setSecretaria(Secretaria secretaria) {
        this.secretaria = secretaria;
    }

    public Usuario getResponsavel() {
        return responsavel;
    }

    public void setResponsavel(Usuario responsavel) {
        this.responsavel = responsavel;
    }

    public Pessoa getEmpresa() {
        return empresa;
    }

    public void setEmpresa(Pessoa empresa) {
        this.empresa = empresa;
    }

    public Endereco getEndereco() {
        return endereco;
    }

    public void setEndereco(Endereco endereco) {
        this.endereco = endereco;
    }

    public Endereco getEnderecoEmpresa() {
        return enderecoEmpresa;
    }

    public void setEnderecoEmpresa(Endereco enderecoEmpresa) {
        this.enderecoEmpresa = enderecoEmpresa;
    }

    public List<Secretaria> getSecretarias() {
        return secretarias;
    }

    public void setSecretarias(List<Secretaria> secretarias) {
        this.secretarias = secretarias;
    }

    public Usuario getResponsavelPesquisar() {
        return responsavelPesquisar;
    }

    public void setResponsavelPesquisar(Usuario responsavelPesquisar) {
        this.responsavelPesquisar = responsavelPesquisar;
    }

    public Pessoa getEmpresaPesquisar() {
        return empresaPesquisar;
    }

    public void setEmpresaPesquisar(Pessoa empresaPesquisar) {
        this.empresaPesquisar = empresaPesquisar;
    }

    public List<Pessoa> getEmpresas() {
        return empresas;
    }

    public void setEmpresas(List<Pessoa> empresas) {
        this.empresas = empresas;
    }

    public DualListModel<Usuario> getAcompanhantes() {
//        acompanhantes = new DualListModel<Usuario>(usuarioServico.notContainsIn(usuarios), target);
        return acompanhantes;
    }

    public void setAcompanhantes(DualListModel<Usuario> acompanhantes) {
        this.acompanhantes = acompanhantes;
    }

    public CartesianChartModel getGrf() {
        return grf;
    }

    public void setGrf(CartesianChartModel grf) {
        this.grf = grf;
    }

    public List<Anexo> getAnexoComentario() {
        return anexoComentario;
    }

    public void setAnexoComentario(List<Anexo> anexoComentario) {
        this.anexoComentario = anexoComentario;
    }
}
